// cf514e
// 题意：有一棵有根无穷树，每个节点都有n(<=10^5)个儿子节点，每个节点到其
//       第i个儿子节点的距离是di(1<=di<=100)，现在问从根节点出发，到某个
//       点距离不超过x(x<=10^9)的节点的个数。方案数模除10^9+7。
// 题解：一开始的dp方程直接是dp[x]为不超过x的节点个数，这样得到的转移始终
//       结尾有个+1，很难用矩阵优化。事实上，假设dp[x]表示从根节点出发到
//       距离恰巧为x的节点个数，这样转移就是
//       dp[x]=sigma(count[i]*dp[x - i], i from 1 to 100), 
//       最后答案是sum=sigma(dp[i], i from 0 to to x)。
//       这样就可以搞一个101*101的矩阵，一个101*1的列向量，前100个表示前一次
//       递推的100个状态，第101个表示从0到当前最后元素的和，然后乘以矩阵
//       递推。如果x<=100直接dp，超过100就用矩阵快速幂，最终结果的列向量
//       的101个元素就是答案。
//
// run: $exec < input
#include <iostream>
#include <utility>
#include <vector>

int const maxn = 107;
long long const mod = 1000000007;
long long dp[maxn];
int count[maxn];
int n, x;

struct matrix
{
	using value_type = long long;
	using row_type = std::vector<value_type>;

	matrix(int ro, int co)
	{
		mat.resize(ro);
		for (auto & i : mat) i.resize(co);
	}

	matrix(int n) : matrix(n, n)
	{
		for (int i = 0; i < n; i++) mat[i][i] = 1;
	}

	matrix() = default;

	int row() const { return mat.size(); }
	int col() const { return mat[0].size(); }

	row_type       & operator[](int x)       { return mat[x]; }
	row_type const & operator[](int x) const { return mat[x]; }

	private:
	std::vector<row_type> mat;
};

matrix operator*(matrix const & a, matrix const & b)
{
	int n = a.row(), m = b.col(), t = a.col();
	matrix r(n, m);
	for (int i = 0; i < n; i++)
		for (int j = 0; j < m; j++)
			for (int k = 0; k < t; k++)
				r[i][j] = (r[i][j] + (a[i][k] * b[k][j]) % mod) % mod;
	return r;
}

matrix quick_pow(matrix const & a, int b)
{
	if (!b) return matrix(a.row());

	matrix ret = quick_pow(a, b / 2);
	ret = ret * ret;
	if (b & 1) ret = ret * a;
	return ret;
}

void test()
{
	int n = 2;
	matrix tmp(n);
	tmp[0][1] = 1;
	tmp = quick_pow(tmp, 3);

	for (int i = 0; i < n; i++) {
		for (int j = 0; j < n; j++) {
			std::cout << tmp[i][j] << ' ';
		}
		std::cout << '\n';
	}
}

int main()
{
	std::ios::sync_with_stdio(false);
//	test();

	std::cin >> n >> x;
	for (int i = 0, t; i < n; i++) {
		std::cin >> t;
		count[t]++;
	}
	long long sum = dp[0] = 1;
	for (int i = 1; i <= std::min(100, x); i++) {
		for (int j = 1; j <= i; j++)
			dp[i] = (dp[i] + (dp[i - j] * count[j]) % mod) % mod;
		sum = (sum + dp[i]) % mod;
	}

	if (x <= 100) { std::cout << sum << '\n'; return 0; }

	matrix a(101, 101);
	for (int i = 0; i < 99; i++)
		a[i][i + 1] = 1;
	for (int i = 0; i < 100; i++)
		a[100][i] = a[99][i] = count[100 - i];
	a[100][100] = 1;
	a = quick_pow(a, x - 100);
	matrix init(101, 1);
	for (int i = 0; i < 100; i++) init[i][0] = dp[i + 1];
	init[100][0] = sum;
	init = a * init;
	std::cout << init[100][0] << '\n';
}

